#include<iostream>
#include<unistd.h>
#include<pthread.h>//原生线程库的头文件
#include<sys/types.h>
#include<unistd.h>
#include<cstring>
#include<stdlib.h>
#include<vector>

std::string ToHex(int argu)
{
	char buff[64];
	snprintf(buff,sizeof(buff),"0x%x",argu);
	return buff;
}
//验证每个线程都有自己独立的栈结构


//验证线程的局部存储
//int g_value = 100;
__thread int g_value = 100;
void* newthread1(void* args)
{

	std::string name = static_cast<char*>(args);
	while(true)
	{
		sleep(1);
		std::cout<<name<<" is run ..,g_value: "<<g_value<<"  &g_value: "<<&g_value<<std::endl;
		g_value--;
	}
	return nullptr;
}

void* newthread2(void* args)
{
	std::string name = static_cast<char*>(args);
	while(true)
	{
		sleep(1);
		std::cout<<name<<" is run ..,g_value: "<<g_value<<"  &g_value: "<<&g_value<<std::endl;
	}
	return nullptr;
}
int main()
{
	pthread_t tid1;
	pthread_t tid2;
	void* ret = nullptr;
	pthread_create(&tid1,nullptr,newthread1,(void*)"thread-1");
	pthread_create(&tid2,nullptr,newthread2,(void*)"thread-2");
	pthread_detach(tid1);
	pthread_detach(tid2);
	int cnt = 20;
	while(cnt--)
	{
		sleep(1);
	}
	return 0;
}
































// const int num = 5;
// //任务类
// class Task
// {
// 	public:
// 		Task(int x,int y)
// 		:_x(x)
// 		,_y(y)
// 		{}
// 		~Task()
// 		{}
// 		int Excute()
// 		{
// 			return _x+_y;
// 		}
// 	private:
// 		int _x;
// 		int _y;
// };
// //线程的信息和要执行的任务
// class ThreadData
// {
// 	public:
// 		ThreadData(int x,int y,std::string threadname)
// 		:_threadname(threadname)
// 		,_ptr(x,y)
// 		{}
// 		std::string name()
// 		{
// 			return _threadname;
// 		}
// 		int run()
// 		{
// 			return _ptr.Excute();
// 		}
// 	private:
// 	std::string _threadname;
// 	Task _ptr;
// };
// //返回结果类

// class Result
// {
// 	public:
// 	Result(int result,std::string threadname)
// 	:_result(result)
// 	,_threadname(threadname)
// 	{}
// 	~Result()
// 	{}
// 	void print()
// 	{
// 		std::cout<<_threadname<<" result is : "<<_result<<std::endl;
// 	}
// 	private:
// 	int _result;
// 	std::string _threadname;
// };
// void* handlertask(void* args)
// {
// 	ThreadData* data_ptr = static_cast<ThreadData*>(args);
// 	int result = data_ptr->run(); 
// 	std::string name = data_ptr->name();
// 	Result * ret = new Result(result,name);
// 	delete data_ptr;
// 	return ret;
// }
// int main()
// {
// 	std::vector<pthread_t> threads;
// 	//创建线程
// 	for(int i = 0; i < num; i++)
// 	{
// 		pthread_t rid;
// 		char* threadname = new char[64];
// 		snprintf(threadname,64,"thread_%d",i+1);//向缓冲区内写入线程号
// 		ThreadData* data_ptr = new ThreadData(10,20,threadname);
// 		pthread_create(&rid,nullptr,handlertask,data_ptr);
// 		threads.push_back(rid);//收集各线程的id信息
// 	}
// 	std::vector<Result*> result;
// 	//线程回收
// 	void* ret = nullptr;
// 	for(auto& tid : threads)
// 	{
// 		pthread_join(tid,&ret);
// 		result.push_back(static_cast<Result*>(ret));
// 	}
// 	//结果打印
// 	for(auto& ret: result)
// 	{
// 		ret->print();
// 		delete ret;
// 	}
// 	return 0;
// }












// #include<iostream>
// #include<thread>
// #include<unistd.h>
// void handler(int args)
// {
// 	std::cout<<"new thread is runing ...,argu is: "<<args<<std::endl; 
// 	return;
// }
// int main()
// {
// 	std::thread t0(handler,10);
// 	std::thread t1(handler,11);
// 	std::thread t2(handler,12);
// 	std::thread t3(handler,13);
// 	t0.join();
// 	t1.join();
// 	t2.join();
// 	t3.join();
// 	while(true)
// 	{
// 		std::cout<<"main thread is run ..."<<std::endl;
// 		sleep(1);
// 	}
// 	return 0;
// }









// void* handler_task(void* args)
// {
// 	const char* name = static_cast<char*>(args);
// 	int cnt = 5;
// 	while(cnt--)
// 	{
// 		sleep(1);
// 		std::cout<<name<<" is runing ..."<<std::endl;
// 	}
// 	delete[] name;
// 	return nullptr;
// }

// const int num = 5;
// int main()
// {
// 	std::vector<pthread_t> threads;
// 	for(int i = 0;i<num;i++)
// 	{
// 		pthread_t tid;
// 		char* threadname = new char[64];
// 		snprintf(threadname,64,"thread-%d",i+1);
// 		pthread_create(&tid,nullptr,handler_task,threadname);
// 		threads.push_back(tid);
// 	}
// 	for(auto& tid :threads)
// 	{
// 		pthread_join(tid,nullptr);
// 		std::cout<<" wait thread id: "<<tid<<" success ..."<<std::endl;
// 	}
// 	return 0;
// }

























// void* newthread_1(void* args)
// {
//     std::cout<<"newthread_1 is runing ..."<<std::endl;
// 	int *p = (int*)malloc(sizeof(int));
// 	*p = 1;
// 	return (void*)p;
// }

// void* newthread_2(void* args)
// {
// 	std::cout<<"newthread_2 is runing ..."<<std::endl;
// 	int *p = (int*)malloc(sizeof(int));
// 	*p = 1;

// 	pthread_exit((void*)p);
// }

// void* newthread_3(void* args)
// {
// 	while(true)
// 	{
// 		std::cout<<"newthread_3 is runing ..."<<std::endl;
// 		sleep(1);
// 	}
// 	return nullptr;
// }
// int main()
// {
//     void* ret = nullptr;
//     pthread_t tid;

// 	//thread 1 return 
//     pthread_create(&tid,nullptr,newthread_1,nullptr);
// 	pthread_join(tid,&ret);
// 	std::cout<<"newthread_1 return, thread id: "<<tid<<"  return code: "<<*(int*)ret<<std::endl;
// 	//(long long)ret 实际上是打印指针的地址，而不是指针的指向的值，ret是指向动态分配的整数的指针
// 	free(ret);

// 	//thread 2 pthread_exit
// 	pthread_create(&tid,nullptr,newthread_2,nullptr);
// 	pthread_join(tid,&ret);
// 	std::cout<<"newthread_2 exit, thread id: "<<tid<<"  return code: "<<*(int*)ret<<std::endl;
// 	free(ret);

// 	//thread 3 pthread_cancel

// 	pthread_create(&tid,nullptr,newthread_3,nullptr);
// 	sleep(3);
// 	pthread_cancel(tid);
// 	pthread_join(tid,&ret);
// 	if(ret == PTHREAD_CANCELED)
// 		std::cout<<"newthread_3 exit, thread id: "<<(long long)tid<<"  return code: "<<" PTHREAD_CANCELED "<<std::endl;
// 	else
// 		std::cout<<"newthread_3 exit, thread id: "<<(long long)tid<<"  return code: "<<" nullptr "<<std::endl;
// 	//free(ret);会出现Segmentation fault 错误，原因：线程被取消，根本就没有返回值，pthread_join函数返回PTHREAD_CANCELED，
// 	//这意味ret不会是动态分配内存的指针，而是而是PTHREAD_CANCELED的宏值。因此尝试对ret调用free是错误的
//    return 0;
// }








// void* newthread(void* args)
// {
//     int cnt = 2;
// 	while(cnt--)
//     {
//         sleep(1);
//         std::cout<<"new thread is run..."<<std::endl;
//     }
//     std::cout<<"new thread quit..."<<std::endl;
//     pthread_exit((void*)100);
// 	return nullptr;
// }
// int main()
// {
// 	void* ret;
// 	pthread_t tid;
// 	pthread_create(&tid,nullptr,newthread,nullptr);
// 	int cnt = 4;
// 	while(cnt--)
// 	{
// 		sleep(1);
// 		std::cout<<"main thread is run... "<<std::endl;
// 	}
// 	pthread_join(tid,&ret);
// 	std::cout<<"new thread return inf: "<<(long long)ret<<std::endl;
// 	std::cout<<"main thread quit ... "<<std::endl;
// 	return 0;
// }




// void* newthread(void* args)
// {
//     int cnt = 5 ;
//     while(cnt--)
//     {
//         sleep(1);
//         if(cnt == 2)
//         {
//             int *ptr = nullptr;
//             *ptr = 100;//野指针
//         }
//         std::cout<<"new thread is run ..."<<std::endl;
//     }

//     return nullptr;
// }
// int main()
// {
// 	pthread_t tid;
//    	pthread_create(&tid,nullptr,newthread,nullptr);
//     //主进程永远不会退出
//     while(true)
//     {
//         sleep(1);
//         std::cout<<"main thread is run ..."<<std::endl;
//     }
//     pthread_join(tid,nullptr);
//     sleep(5);
//     return 0;
// }




// int global_val = 100;
// void* newthread(void* args)
// {
//     int cnt = 5;
//     while(true)
//     {
//         global_val++;
//         std::cout<<"new thread is run..,global_val:  "<<global_val<<"  &global_val:"<<&global_val<<std::endl;
//         sleep(1);
//     }
//     return nullptr;
// }
// int main()
// {
// 	pthread_t tid;
//    	pthread_create(&tid,nullptr,newthread,nullptr);
//     while(true)
//     {
//         std::cout<<"main thread is run..,global_val:  "<<global_val<<"  &global_val:"<<&global_val<<std::endl;
//         sleep(1);
//     }
//     pthread_join(tid,nullptr);
//     sleep(5);
//     return 0;
// }




// void* newthreadrun(void *args)
// {
// 	int cnt = 3;
// 	while(cnt--)
//     {
//         std::cout<<"new thread is run ..."<<std::endl;
//         sleep(1);
//     }
//     std::cout<<"new thread quit new ..."<<std::endl;
//     return (void*)100;
// }
// int main()
// {
// 	void* retval;
// 	pthread_t tid;
// 	pthread_create(&tid,nullptr,newthreadrun,nullptr);
// 	int n = pthread_join(tid,&retval);
//     sleep(1);
//     std::cout<<"main thread quit ... ,return inf: "<<(long long)retval<<" return vlue: "<< n<<std::endl;
// 	return 0;
// }

// void * newthreadrun(void* args)
// {
//     int cnt = 10;
//     while(cnt--)
//     {
//         std::cout<<"I am new thread "<<std::endl;
//         sleep(1);
//     }
//     return nullptr;
// }
// int main()
// {
// 	pthread_t tid;
//     pthread_create(&tid,nullptr,newthreadrun,nullptr);
//     sleep(1);
//     return 0;
// }
// std::string ToHex(pthread_t tid)
// {
//     char id[64];
//     snprintf(id,sizeof(id),"0x%lx",tid);
//     return id;
// }
// void* threadrun(void* args)
// {
//     char* name = (char*)args;
//     int cnt = 5;
//     while(cnt)
//     {
//         cnt--;
//         std::cout<< name<<" is runing: "<<cnt<<" ,getpid: "
//         <<getpid()<<"   mythread id: "<<ToHex(pthread_self())<<std::endl;
//         sleep(1);
//     }
//     return nullptr;
// }
// int main()
// {
//     pthread_t tid;
//     pthread_create(&tid,nullptr,threadrun,(void*)"thread-1");
//     int cnt = 10;
//     while(cnt)
//     {
//         cnt--;
//         std::cout<<"main thread is runing "<<cnt<<",getpid: "<<getpid()
//         <<" new thread id: " <<ToHex(tid)<<" main thread id: "
//         <<ToHex(pthread_self())<<std::endl;
//         sleep(1);
//     }
// }